{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "9479f1e0",
   "metadata": {},
   "source": [
    "# 量子神经网络的表达能力\n",
    "\n",
    "<em>Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved.</em>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c352b2aa",
   "metadata": {},
   "source": [
    "## 概览"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a195bcc",
   "metadata": {},
   "source": [
    "在量子机器学习中，量子神经网络的**表达能力**是决定量子机器学习任务能否成功的关键因素。一般来说，量子神经网络拟设的表达能力越强，量子机器学习能够搜索到全局最优解的可能性就越大。本教程首先介绍量子神经网络表达能力的基本概念，随后将在量桨中展示如何通过布洛赫球感受不同拟设表达能力的差别。最后介绍一种定量分析量子神经网络表达能力的方法，并评估量桨提供的量子神经网络模板在不同深度下的表达能力。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0f4583d7",
   "metadata": {},
   "source": [
    "## 基本概念"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c03d7dcf",
   "metadata": {},
   "source": [
    "我们先来回顾一下量子机器学习算法的基本流程。在量子机器学习中，我们往往设计一个损失函数 $\\mathcal{L}$，并通过优化一个酉变换 $U$ 使得损失函数最小化：\n",
    "\n",
    "$$\n",
    "\\min_U\\mathcal{L}(U)=\\min_U \\text{tr}[HU\\rho_{in}U^\\dagger],\\tag{1}\n",
    "$$\n",
    "\n",
    "算法背后的数学原理保证当我们遍历完所有可能的酉变换后，损失函数能取到的最小值就对应于我们问题的解。而在实际操作中，我们采用量子神经网络将酉变换参数化：\n",
    "\n",
    "$$\n",
    "U=U(\\vec{\\theta})=U_D(\\vec{\\theta}_D)\\dots U_1(\\vec{\\theta}_1),\\tag{2}\n",
    "$$\n",
    "\n",
    "其中每个 $U_j(\\vec{\\theta}_j),j\\in[1,D]$ 代表一层量子神经网络，$\\vec{\\theta}_j$ 代表该层对应的参数。此时，通过调整量子神经网络中的参数 $\\vec{\\theta}$，我们就可以进行对酉变换 $U$ 的优化，进而最小化损失函数 $\\mathcal{L}$：\n",
    "\n",
    "$$\n",
    "\\min_{\\vec{\\theta}}\\mathcal{L}(\\vec{\\theta})=\\min_{\\vec{\\theta}} \\text{tr}[HU(\\vec{\\theta})\\rho_{in}U(\\vec{\\theta})^\\dagger].\\tag{3}\n",
    "$$\n",
    "\n",
    "然而，细心的读者此时可能已经发现了量子神经网络的一个不足：对于一个给定的神经网络拟设，**遍历所有的参数并不一定可以保证遍历所有的酉变换**。作为一个简单的例子，如果我们只允许使用一个 $R_Y$ 旋转门作为单比特量子神经网络 $U(\\theta)=R_Y(\\theta)$，显然（除去全局相位）$U(\\theta)$ 不能表示任何矩阵元含虚部的复酉矩阵。而当允许使用 $R_Y$ 和 $R_Z$ 旋转门时，如果我们搭建量子神经网络为 $U(\\vec{\\theta})=R_Z(\\theta_1)R_Y(\\theta_2)R_Z(\\theta_3)$，$U(\\vec{\\theta})$ （除去全局相位）将能够表示所有的单比特酉矩阵 [1]。\n",
    "\n",
    "如果我们将神经网络的表达能力定义为**在遍历电路参数 $\\vec{\\theta}$ 时电路能够表达的酉变换的多少**，那么，一个表达能力强的量子神经网络将更有可能包含那些使得损失函数 $\\mathcal{L}$ 取到全局最小值的酉变换；相反地，如果一个量子神经网络 $U_{weak}$ 的表达能力太弱以至于不包含任何能将损失函数最小化的酉变换，那么基于优化 $U_{weak}$ 的量子机器学习任务就很可能会失败。\n",
    "\n",
    "接下来我们基于量桨，通过观察单量子比特酉门遍历布洛赫球的能力直观地感受量子神经网络的表达能力。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3412d8c6",
   "metadata": {},
   "source": [
    "## 直观感受表达能力：遍历布洛赫球"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5bd49ecf",
   "metadata": {},
   "source": [
    "对于单量子比特的简单情况，我们可以直接观察量子神经网络如何将固定输入遍历布洛赫球表面。对于一个给定的神经网络拟设 $U(\\vec{\\theta})$，由于网络的输入往往是固定的（不妨设为 $|0\\rangle$），通过均匀地采样神经网络参数 $\\vec{\\theta}$，神经网络的输出态 $U(\\vec{\\theta})|0\\rangle$ 将散落在布洛赫球表面。显然，如果输出态在球面分布地越广越均匀，那么神经网络拟设 $U$ 的表达能力也就越强，包含损失函数全局最优的可能性也就越大。\n",
    "\n",
    "为在量桨实现这一功能，首先引入必要的包："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "e05a5803",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import paddle\n",
    "import paddle_quantum as pq\n",
    "from paddle_quantum.ansatz.circuit import Circuit\n",
    "from paddle_quantum.visual import plot_state_in_bloch_sphere"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "14f70b6b",
   "metadata": {},
   "source": [
    "首先，我们只允许使用一个 $R_Y$ 旋转门作为单比特量子神经网络 $U(\\theta)=R_Y(\\theta)$。通过在 $[0,2\\pi]$ 均匀采样参数 $\\theta$ 并将 $U(\\theta)$ 作用在固定输入 $|0\\rangle$ 上，我们便得到量子神经网络 $U(\\theta)$ 的输出分布。通过量桨内置的 plot_bloch_sphere_from_input 函数，我们可以直接观察 $U(\\theta)|0\\rangle$ 在布洛赫球面上的分布："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "04344561",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "num_qubit = 1      # 设定量子比特数\n",
    "num_sample = 2000  # 设定采样次数\n",
    "outputs_y = list()   # 储存采样电路输出\n",
    "\n",
    "for _ in range(num_sample):\n",
    "    # 初始化量子神经网络\n",
    "    pq.set_backend('density_matrix')\n",
    "    cir = Circuit(num_qubit)\n",
    "    # 作用 Ry 旋转门，旋转角度随机\n",
    "    cir.ry(0)\n",
    "    # 输出态的密度矩阵\n",
    "    rho = cir(pq.state.zero_state(num_qubit))\n",
    "    outputs_y.append(rho)\n",
    "    \n",
    "# 量桨内置的 plot_bloch_sphere_from_input 函数\n",
    "# plot_state_in_bloch_sphere(outputs_y, save_gif=True, filename='figures/bloch_y.gif')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97e80f54",
   "metadata": {},
   "source": [
    "![bloch_y.gif](./figures/expressibility-fig-bloch_y.gif)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7198779e",
   "metadata": {},
   "source": [
    "可见，量子神经网络 $U(\\theta)=R_Y(\\theta)$ 的输出只能分布于布洛赫球面上的一个圆环（尽管在圆环上的分布是均匀的）。类似地，我们考虑包含两个参数的神经网络 $U(\\vec{\\theta})=R_Y(\\theta_1)R_Z(\\theta_2)$ 和 三个参数的神经网络 $U(\\vec{\\theta})=R_Y(\\theta_1)R_Z(\\theta_2)R_Y(\\theta_3)$ 的输出分布："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "0530af37",
   "metadata": {},
   "outputs": [],
   "source": [
    "outputs_yz = list()   # 储存采样电路输出\n",
    "for _ in range(num_sample):\n",
    "    # 初始化量子神经网络\n",
    "    cir = Circuit(num_qubit)\n",
    "    # 作用 Ry 和 Rz 旋转门，旋转角度随机\n",
    "    cir.ry(0)\n",
    "    cir.rz(0)\n",
    "    # 输出态的密度矩阵\n",
    "    rho = cir(pq.state.zero_state(num_qubit))\n",
    "    outputs_yz.append(rho)\n",
    "\n",
    "# plot_state_in_bloch_sphere(outputs_yz, save_gif=True, filename='figures/bloch_yz.gif')\n",
    "\n",
    "\n",
    "outputs_yzy = list()   # 储存采样电路输出\n",
    "for _ in range(num_sample):\n",
    "    # 初始化量子神经网络\n",
    "    cir = Circuit(num_qubit)\n",
    "    # 作用 Ry,Rz,Ry 旋转门，旋转角度随机\n",
    "    cir.ry(0)\n",
    "    cir.rz(0)\n",
    "    cir.ry(0)\n",
    "    # 输出态的密度矩阵\n",
    "    rho = cir(pq.state.zero_state(num_qubit))\n",
    "    outputs_yzy.append(rho)\n",
    "    \n",
    "# plot_state_in_bloch_sphere(outputs_yzy, save_gif=True, filename='figures/bloch_yzy.gif')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8dbde635",
   "metadata": {},
   "source": [
    "![bloch_yz.gif](./figures/expressibility-fig-bloch_yz.gif)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58b0d055",
   "metadata": {},
   "source": [
    "![bloch_yzy.gif](./figures/expressibility-fig-bloch_yzy.gif)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e195d35",
   "metadata": {},
   "source": [
    "可见，神经网络 $U(\\vec{\\theta})=R_Y(\\theta_1)R_Z(\\theta_2)$ 的输出可以分布在整个布洛赫球表面了，虽然在两级（$|0\\rangle$ 和 $|1\\rangle$）附近的分布会更加密集；而神经网络 $U(\\vec{\\theta})=R_Y(\\theta_1)R_Z(\\theta_2)R_Y(\\theta_3)$ 的输出在球面的分布是比较均匀的。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7972ed41",
   "metadata": {},
   "source": [
    "在单量子比特的低维情形下我们可以借助布洛赫球定性观察量子神经网络的表达能力。而在一般的多量子比特应用中，我们必须借助统计数学的工具对表达能力定量分析。接下来我们将引入量子态之间保真度分布的 K-L 散度作为量化神经网络的表达能力的指标，并计算一种常见拟设的表达能力。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "11ca0aeb",
   "metadata": {},
   "source": [
    "## 定量分析表达能力：K-L 散度"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1275e46a",
   "metadata": {},
   "source": [
    "### 保真度分布与 K-L 散度"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "54ae96a6",
   "metadata": {},
   "source": [
    "在文献 [2] 中，作者提出了基于神经网络输出态之间的保真度概率分布的表达能力量化方法。对任意量子神经网络 $U(\\vec{\\theta})$，采样两次神经网络参数（设为 $\\vec{\\phi}$ 和 $\\vec{\\psi}$），则两个量子电路输出态之间的保真度 $F=|\\langle0|U(\\vec{\\phi})^\\dagger U(\\vec{\\psi})|0\\rangle|^2$ 服从某个概率分布：\n",
    "$$\n",
    "F\\sim{P}(f).\\tag{4}\n",
    "$$\n",
    "文献 [2] 指出，量子神经网络 $U$ 能够均匀地分布在所有酉矩阵上时（此时称 $U$ 服从哈尔分布），保真度的概率分布 $P_\\text{Haar}(f)$ 满足\n",
    "$$\n",
    "P_\\text{Haar}(f)=(2^{n}-1)(1-f)^{2^n-2}.\\tag{5}\n",
    "$$\n",
    "\n",
    "量桨提供了直接从哈尔分布采样酉矩阵的函数。观察哈尔分布酉矩阵输出的量子态保真度服从的概率分布："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "b9dbeb68",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from paddle_quantum.linalg import haar_unitary\n",
    "from paddle_quantum.qinfo import state_fidelity\n",
    "from paddle_quantum.state.common import to_state\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.ticker import FuncFormatter\n",
    "from scipy import integrate\n",
    "\n",
    "# 定义绘制直方图的函数\n",
    "def plot_hist(data, num_bin, title_str):\n",
    "    def to_percent(y, position):\n",
    "        return str(np.around(y*100, decimals=2)) + '%'\n",
    "    plt.hist(data, weights=[1./len(data)]*len(data), bins=np.linspace(0, 1, num=num_bin), facecolor=\"blue\", edgecolor=\"black\", alpha=0.7)\n",
    "    plt.xlabel(\"Fidelity\")\n",
    "    plt.ylabel(\"frequency\")\n",
    "    plt.title(title_str)\n",
    "    formatter = FuncFormatter(to_percent)\n",
    "    plt.gca().yaxis.set_major_formatter(formatter)\n",
    "    plt.show()\n",
    "    \n",
    "    \n",
    "# 定义计算哈尔采样输出保真度分布的函数\n",
    "def p_F_haar(n, s, b=50, draw=False):\n",
    "    f_list = list()\n",
    "    # 开始采样\n",
    "    for i in range(s):\n",
    "        # 采样第一个酉变换\n",
    "        u1 = haar_unitary(n)\n",
    "        # 输入 |0> 时酉变换的输出\n",
    "        phi1 = u1[:,0]\n",
    "        rho1 = to_state(np.outer(phi1, phi1.conj()))\n",
    "        # 采样第二个酉变换\n",
    "        u2 = haar_unitary(n)\n",
    "        phi2 = u2[:,0]\n",
    "        # 输入 |0> 时酉变换的输出\n",
    "        rho2 = to_state(np.outer(phi2, phi2.conj()))\n",
    "        # 计算两个采样输出之间的保真度\n",
    "        f_list.append(state_fidelity(rho1, rho2)**2)\n",
    "    f_list = np.array(f_list)\n",
    "    # 绘制概率分布图\n",
    "    if draw:\n",
    "        title_str = \"haar, %d qubit(s)\" % num_qubit\n",
    "        plot_hist(f_list, b, title_str)\n",
    "    sample_distribution, _ = np.histogram(f_list, bins=np.linspace(0, 1, num=b), density=True)\n",
    "    # 根据公式计算概率分布函数的理论值，用于后期计算 K-L 散度\n",
    "    theory_distribution = np.zeros_like(sample_distribution)\n",
    "    for index in range(len(theory_distribution)):\n",
    "        def p_continues(f):\n",
    "            return (2 ** n - 1) * (1 - f) ** (2 ** n - 2)\n",
    "        lower = 1/b*index\n",
    "        upper = lower + 1/b\n",
    "        theory_distribution[index], _ = integrate.quad(p_continues,lower,upper)\n",
    "    return sample_distribution, theory_distribution\n",
    "\n",
    "\n",
    "num_qubit = 1\n",
    "p_haar_1qubit, theory_haar_1qubit = p_F_haar(num_qubit, num_sample, draw=True)\n",
    "num_qubit = 2\n",
    "p_haar_2qubit, theory_haar_2qubit = p_F_haar(num_qubit, num_sample, draw=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8680f5b2",
   "metadata": {},
   "source": [
    "可见保真度分布大致服从 $P_\\text{Haar}$。类似地，我们也能计算之前定义的单比特量子神经网络 $R_Y(\\theta)$，$R_Y(\\theta_1)R_Z(\\theta_2)$ 和 $R_Y(\\theta_1)R_Z(\\theta_2)R_Y(\\theta_3)$ 输出的保真度概率分布："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "2af57d70",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 定义计算量子神经网络输出保真度分布的函数\n",
    "def p_F_qnn(n, s, g, b=50, draw=False):\n",
    "    f_list = list()\n",
    "    rho_sample = outputs_y\n",
    "    title_str = \"Ry\"\n",
    "    if g == 2:\n",
    "        rho_sample = outputs_yz\n",
    "        title_str = \"Ry-Rz\"\n",
    "    elif g == 3:\n",
    "        rho_sample = outputs_yzy\n",
    "        title_str = \"Ry-Rz-Ry\"\n",
    "    # 使用之前采样的数据计算保真度分布\n",
    "    for index in range(int(s / 2)):\n",
    "        rho1 = rho_sample[index]\n",
    "        rho2 = rho_sample[index+int(num_sample / 2)]\n",
    "        f_list.append(state_fidelity(rho1, rho2)**2)\n",
    "    f_list = np.array(f_list)\n",
    "    # 绘制概率分布图\n",
    "    if draw:\n",
    "        plot_hist(f_list, b, title_str)\n",
    "    distribution, _ = np.histogram(f_list, bins=np.linspace(0, 1, num=b), density=True)\n",
    "    return distribution\n",
    "    \n",
    "    \n",
    "num_qubit = 1\n",
    "p_y = p_F_qnn(num_qubit, num_sample, 1, draw=True)\n",
    "p_yz = p_F_qnn(num_qubit, num_sample, 2, draw=True)\n",
    "p_yzy = p_F_qnn(num_qubit, num_sample, 3, draw=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "18e05d9e",
   "metadata": {},
   "source": [
    "可见，$R_Y-R_Z-R_Y$ 门组成的神经网络的输出保真度分布与均匀酉矩阵的表现最为接近。统计数学中的 K-L 散度（也称相对熵）可以衡量两个概率分布之间的差异。两个离散概率分布 $P,Q$ 之间的 K-L 散度定义为\n",
    "$$\n",
    "D_{KL}(P||Q)=\\sum_jP(j)\\ln\\frac{P(j)}{Q(j)}.\\tag{6}\n",
    "$$\n",
    "如果将量子神经网络输出的保真度分布记为 $P_\\text{QNN}(f)$，则量子神经网络的表达能力定义为 $P_\\text{QNN}(f)$ 和 $P_\\text{Haar}(f)$ 之间的 K-L 散度 [2]：\n",
    "$$\n",
    "\\text{Expr}_\\text{QNN}=D_{KL}(P_\\text{QNN}(f)||P_\\text{Haar}(f)).\\tag{7}\n",
    "$$\n",
    "因此，当 $P_\\text{QNN}(f)$ 越接近 $P_\\text{Haar}(f)$ 时，$\\text{Expr}$ 将越小（越趋近于 0），量子神经网络的表达能力也就越强；反之，$\\text{Expr}$ 越大，量子神经网络的表达能力也就越弱。\n",
    "\n",
    "我们可以根据该定义直接计算单比特量子神经网络 $R_Y(\\theta)$，$R_Y(\\theta_1)R_Z(\\theta_2)$ 和 $R_Y(\\theta_1)R_Z(\\theta_2)R_Y(\\theta_3)$ 的表达能力："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "1d73cffe",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ry，Ry-Rz，和 Ry-Rz-Rz 神经网络的表达能力分别为 0.24，0.03，和 0.01。\n"
     ]
    }
   ],
   "source": [
    "from scipy.stats import entropy\n",
    "# 使用 scipy 的 entropy 函数计算相对熵（即 K-L 散度）\n",
    "expr_y = entropy(p_y, theory_haar_1qubit)\n",
    "expr_yz = entropy(p_yz, theory_haar_1qubit)\n",
    "expr_yzy = entropy(p_yzy, theory_haar_1qubit)\n",
    "print(\"Ry，Ry-Rz，和 Ry-Rz-Rz 神经网络的表达能力分别为 %.2f，%.2f，和 %.2f。\" %(expr_y, expr_yz, expr_yzy))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e33d696a",
   "metadata": {},
   "source": [
    "###   评估量子神经网络拟设的表达能力"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "763d2532",
   "metadata": {},
   "source": [
    "现在，我们拥有了定量研究任何量子神经网络拟设表达能力的工具——K-L 散度。作为一个实际应用，我们来探究量桨内置拟设 complex_entangled_layer 的表达能力随电路深度的变化。这里我们设置电路的宽度为 4-qubit。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "c557d91a",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "哈尔采样输出的保真度服从分布：\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "正在采样深度为 1 的电路...\n",
      "   采样第 0 个样本...\n",
      "   采样第 400 个样本...\n",
      "   采样第 800 个样本...\n",
      "   采样第 1200 个样本...\n",
      "   采样第 1600 个样本...\n",
      "   采样完毕\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "正在采样深度为 2 的电路...\n",
      "   采样第 0 个样本...\n",
      "   采样第 400 个样本...\n",
      "   采样第 800 个样本...\n",
      "   采样第 1200 个样本...\n",
      "   采样第 1600 个样本...\n",
      "   采样完毕\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "正在采样深度为 3 的电路...\n",
      "   采样第 0 个样本...\n",
      "   采样第 400 个样本...\n",
      "   采样第 800 个样本...\n",
      "   采样第 1200 个样本...\n",
      "   采样第 1600 个样本...\n",
      "   采样完毕\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "深度为 1,2,3 的神经网络的表达能力分别为 [0.2949 0.0234 0.0077]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 定义计算保真度分布的函数\n",
    "def p_F_cel(n, d, s, b=50, draw=False):\n",
    "    pq.set_backend('state_vector')\n",
    "    f_list = list()\n",
    "    for index in range(int(s / 2)):\n",
    "        if 2 * index % 400 == 0:\n",
    "            print(\"   采样第 %d 个样本...\" % (2 * index))\n",
    "        cir1 = Circuit(n)\n",
    "        # 作用 complex_entangled_layer 层\n",
    "        cir1.complex_entangled_layer('full', n, d)\n",
    "        # 输出态的态矢量\n",
    "        rho1 = cir1(pq.state.zero_state(n))\n",
    "        \n",
    "        cir2 = Circuit(n)\n",
    "        # 作用 complex_entangled_layer 层\n",
    "        cir2.complex_entangled_layer('full', n, d)\n",
    "        # 输出态的态矢量\n",
    "        rho2 = cir2(pq.state.zero_state(n))\n",
    "        \n",
    "        # 计算保真度\n",
    "        f_list.append(abs(np.inner(rho1.data.numpy(), rho2.data.numpy().conj())**2))\n",
    "                      \n",
    "    print(\"   采样完毕\")\n",
    "    f_list = np.array(f_list)\n",
    "    # 绘制概率分布图\n",
    "    if draw:\n",
    "        title_str = \"complex entangled layer, %d layer(s)\" % d\n",
    "        plot_hist(f_list, b, title_str)\n",
    "    distribution, _ = np.histogram(f_list, bins=np.linspace(0, 1, num=b), density=True)\n",
    "    return distribution\n",
    "\n",
    "\n",
    "# 设置电路宽度和最大深度\n",
    "num_qubit = 4\n",
    "max_depth = 3\n",
    "# 计算哈尔采样对应的保真度分布\n",
    "print(\"哈尔采样输出的保真度服从分布：\")\n",
    "p_haar_4qubit, theory_haar_4qubit = p_F_haar(num_qubit, num_sample, draw=True)\n",
    "Expr_cel = list()\n",
    "# 计算不同深度的神经网络的表达能力\n",
    "for DEPTH in range(1, max_depth + 1):\n",
    "    print(\"正在采样深度为 %d 的电路...\" % DEPTH)\n",
    "    p_cel = p_F_cel(num_qubit, DEPTH, num_sample, draw=True)\n",
    "    expr = entropy(p_cel, theory_haar_4qubit)\n",
    "    Expr_cel.append(expr)\n",
    "# 比较不同深度的神经网络的表达能力\n",
    "print(\"深度为 1,2,3 的神经网络的表达能力分别为\", np.around(Expr_cel, decimals=4))\n",
    "plt.plot(range(1, max_depth + 1), Expr_cel, marker='>')\n",
    "plt.xlabel(\"depth\")\n",
    "plt.yscale('log')\n",
    "plt.ylabel(\"Expr.\")\n",
    "plt.xticks(range(1, max_depth + 1))\n",
    "plt.title(\"Expressibility vs Circuit Depth\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f1b3485",
   "metadata": {},
   "source": [
    "可见随着电路深度的增加，量子神经网络的表达能力也在逐渐增强。感兴趣的读者不妨自己动手尝试一下其他量桨内置拟设的表达能力计算，以及比较不同拟设之间表达能力的差别。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e5dd645",
   "metadata": {},
   "source": [
    "_______\n",
    "\n",
    "## 参考文献\n",
    "\n",
    "[1] Nielsen, Michael A., and Isaac L. Chuang. \"Quantum Computation and Quantum Information.\" Cambridge University Press, 2010.\n",
    "\n",
    "[2] Sim, Sukin, Peter D. Johnson, and Alán Aspuru‐Guzik. \"Expressibility and entangling capability of parameterized quantum circuits for hybrid quantum‐classical algorithms.\" [Advanced Quantum Technologies 2.12 (2019): 1900070](https://onlinelibrary.wiley.com/doi/abs/10.1002/qute.201900070)."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
